home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Sample Code / AOCE Sample Code / PowerTalk Access Modules / Sample PMSAM / PMSAM Framework / RoboSamSlot / CTBChannel.cp < prev    next >
Encoding:
Text File  |  1995-07-28  |  23.8 KB  |  1,168 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        CTBChannel.cp
  3.  
  4.     Contains:    xxx put contents here xxx
  5.  
  6.     Written by:    Tim Harnett
  7.  
  8.     Copyright:    © 1994 by Apple Computer, Inc., all rights reserved.
  9.  
  10.     Change History (most recent first):
  11.  
  12.         <33>      3/6/95    TMH        adapt to use Symantic compiler
  13.         <32>     2/27/95    TMH        adapt to use ETO16 universal headers
  14.         <31>     2/21/95    TMH        metrowerks compatiblity changes
  15.         <30>     2/15/95    TMH        moved gEnableIOTrace
  16.         <29>    12/16/94    TMH        fix so no error is logged when server not available
  17.         <28>    12/12/94    TMH        use of gCurrentThread->Yield()
  18.         <27>    11/17/94    TMH        fixes to wakeup thread
  19.         <26>    11/10/94    TMH        use StopForIO
  20.         <25>     11/8/94    TMH        changes to support async P3 thread
  21.         <24>     11/2/94    JHB        Adding support for Sending eWorld Mail
  22.         <23>     11/2/94    TMH        IO trace stuff
  23.         <22>     11/2/94    TMH        added no carrier detect stuff, and WriteBytes
  24.         <21>    10/28/94    TMH        Open, Read etc return osErr instead of fail
  25.         <20>    10/28/94    TMH        made async and X25 work better
  26.         <19>    10/26/94    TMH        some tweaks with the asynchronous stuff
  27.         <18>    10/25/94    TMH        made open,close, read & write asynchronous
  28.         <15>    10/24/94    JHB        Correct CMRead ASSERT
  29.         <14>    10/21/94    TMH        created TModemChannel and TX25Channel
  30.         <12>    10/20/94    TMH        cleaned up ICTBChannel
  31.         <11>    10/20/94    TMH        cleaned up ICTBChannel
  32.         <10>    10/18/94    TMH        pass external slot to ICTBChannel, some clean up
  33.         <10>    10/18/94    TMH        pass external slot to ICTBChannel, some clean up
  34.  
  35.     To Do:
  36. */
  37.  
  38.  
  39. #ifndef __ERRORS__
  40. #include "Errors.h"
  41. #endif
  42.  
  43. #include    <String.h>
  44. #include    <Strings.h>
  45. #include    <StdIO.h>
  46.  
  47.  
  48. #ifndef __RESOURCES__
  49. #include "Resources.h"
  50. #endif
  51.  
  52. #ifndef __CRecordID__
  53. #include "CRecordID.h"
  54. #endif
  55.  
  56. #ifndef __CommonResources__
  57. #include "CommonResources.h"
  58. #endif
  59.  
  60. #ifndef __CResourceIterator__
  61. #include "CResourceIterator.h"
  62. #endif
  63.  
  64. #ifndef __CAttribute__
  65. #include "CAttribute.h"
  66. #endif
  67.  
  68. #ifndef __PMSAMResources__
  69. #include "PMSAMResources.h"
  70. #endif
  71.  
  72. #ifndef __PMSAMResourceIds__
  73. #include "PMSAMResourceIDs.h"
  74. #endif
  75.  
  76. #ifndef    _CTBCHANNEL_
  77. #include    "CTBChannel.h"
  78. #endif
  79.  
  80. #ifndef    __MSAMSlot__
  81. #include    "MSAMSlot.h"
  82. #endif
  83.  
  84. #ifndef __Debug__
  85. #include "Debug.h"
  86. #endif
  87.  
  88. #ifndef __UFAILURE__
  89. #include "UFailure.h"
  90. #endif
  91.  
  92. #ifndef __TThread__
  93. #include "TThread.h"
  94. #endif
  95. #ifndef __Globals__
  96. #include "Globals.h"
  97. #endif
  98.             
  99. extern Boolean gEnableIOTrace;        // set from resource
  100.         CFile        gReadCaptureFile;
  101.         CFile        gWriteCaptureFile;
  102.         
  103. void EnableIOCapture();        // the compiler insists!
  104. void EnableIOCapture()
  105. {
  106.     
  107.     Str255 uniqueName;
  108.     long now = TickCount();
  109.     CFolder    traceFolder;
  110.     
  111.     OSErr osErr = FocHFSHeirarchyFromResource(kTraceFolderResID,traceFolder);
  112.     ASSERTNOERR(osErr);
  113.     if( osErr == 0 ) {
  114.  
  115.         FileSpecResource** fileSpec = (FileSpecResource**)::GetResource('file',kReadCaptureFileResID);
  116.         ASSERT(fileSpec);
  117.         if( fileSpec == 0 )
  118.             return;
  119.             
  120.  
  121.         uniqueName[0] = sprintf((char*)&uniqueName[1],"%.20P%08x",(*fileSpec)->filename,now);        // concat time stamp with name.
  122.         gReadCaptureFile.SetFSSpec(-1,traceFolder.DirID(),uniqueName);
  123.         OSErr osErr = gReadCaptureFile.Create((*fileSpec)->fileCreator,(*fileSpec)->fileType);
  124.         ASSERTNOERR(osErr);
  125.         osErr = gReadCaptureFile.Open(fsWrPerm);
  126.         ASSERTNOERR(osErr);
  127.  
  128.  
  129.         fileSpec = (FileSpecResource**)::GetResource('file',kWriteCaptureFileResID);
  130.         ASSERT(fileSpec);
  131.         if( fileSpec == 0 )
  132.             return;
  133.             
  134.  
  135.         uniqueName[0] = sprintf((char*)&uniqueName[1],"%.20P%08x",(*fileSpec)->filename,now);        // concat time stamp with name.
  136.         gWriteCaptureFile.SetFSSpec(-1,traceFolder.DirID(),uniqueName);
  137.         osErr = gWriteCaptureFile.Create((*fileSpec)->fileCreator,(*fileSpec)->fileType);
  138.         ASSERTNOERR(osErr);
  139.         osErr = gWriteCaptureFile.Open(fsWrPerm);
  140.         ASSERTNOERR(osErr);
  141.  
  142.  
  143.  
  144.     }
  145.  
  146.  
  147.  
  148. }
  149.  
  150.  
  151. //----------------------------------------
  152. //    TCTBChannel
  153. //----------------------------------------
  154.  
  155. #pragma segment CTBChannel
  156.  
  157. TCTBChannel::TCTBChannel ()
  158. {
  159.  
  160.     fExternalSlot = 0;
  161.     fConnH = 0;
  162.     fWakeupThread = 0;
  163.     
  164.  
  165.         //    Configuration  -- will be overridden by resource values
  166.         
  167.         
  168.     fReadTimeout = -1;
  169.     fWriteTimeout = -1;
  170.     fOpenTimeout = -1;
  171.     fCloseTimeout = -1;
  172.     
  173.     fOpenASync = kDoSync;
  174.     fCloseASync = kDoSync;
  175.     fReadASync = kDoSync;
  176.     fWriteASync = kDoSync;
  177.     
  178.     fConfigBufSize = 512;
  179.  
  180.  
  181.     fBaudRate = 2400;        // default baud setting, lowest usable
  182.     
  183.  
  184.     memset(&fConnEnvironRec, 0, sizeof(ConnEnvironRec));
  185.     
  186.     for( CMBufFields theCurrField = cmDataIn; theCurrField <= cmRsrvOut; theCurrField++)
  187.         fBufferSizesArray[theCurrField] = 0;
  188.  
  189.  
  190.     fBufferSizesArray[cmDataIn] = fBufferSizesArray[cmDataOut] = 1024;
  191. }
  192.  
  193.  
  194.  
  195. //------------------------------------------------------------------------------------
  196. TCTBChannel::~TCTBChannel ()
  197. {
  198.         
  199.     if (fConnH != 0 )
  200.         CMDispose(fConnH);
  201.  
  202.     if( fWakeupThread != 0 ) {    
  203.         ASSERT(fWakeupThread->GetThreadState() == kStoppedThreadState);
  204.         delete fWakeupThread;
  205.     }
  206.  
  207.     if( fCTBIdleThread != 0 ) {    
  208.         ASSERT(fCTBIdleThread->GetThreadState() == kStoppedThreadState);
  209.         delete fCTBIdleThread;
  210.     }
  211.  
  212. }
  213.  
  214.  
  215.  
  216. //------------------------------------------------------------------------------------
  217. void TCTBChannel::ICTBChannel(short toolParamResID,StringPtr toolName, TExternalSlot* exSlot)
  218. {
  219.  
  220.     ASSERT(exSlot);
  221.     
  222.  
  223.     FailInfo         fi;
  224.     Try(fi) 
  225.     {
  226.         fExternalSlot = exSlot;
  227.         
  228.         this->SetCTBParametersFromResource(toolParamResID);
  229.  
  230.  
  231.         this->InitializeCTB();
  232.         
  233.         short    theToolProcID = CMGetProcID(toolName);    
  234.         ASSERT( theToolProcID != -1 );
  235.         if (theToolProcID == -1)
  236.             FailOSErr(errUnableToInitCTB);
  237.  
  238.  
  239.         CMRecFlags  theCMFlags = cmData + cmQuiet + cmNoMenus;
  240.         long        myRefCon = 0;
  241.         long        myUserData = 0;
  242.         
  243.         fConnH = CMNew (theToolProcID, theCMFlags, fBufferSizesArray, myRefCon, myUserData);
  244.         if(!fConnH) {
  245.             ASSERT( fConnH != 0 );
  246.             FailMemError();
  247.         }
  248.  
  249.  
  250.             //    The wakeup thread for async IO.
  251.             
  252.         
  253.         TWakeupThread* wakeupThread = new TWakeupThread;
  254.         wakeupThread->IWakeupThread();
  255.         fWakeupThread = wakeupThread;
  256.  
  257.  
  258.             //    Idle thread -- to assure that CMIdle is called.
  259.             
  260.         TCTBIdleThread* idleThread = new TCTBIdleThread;
  261.         idleThread->ICTBIdleThread(this);
  262.         fCTBIdleThread = idleThread;
  263.         
  264.         CMSetRefCon(fConnH,(long) this);
  265.  
  266.             //    If we'll be capturing get a file for it.
  267.  
  268.         if( gEnableIOTrace )
  269.             ::EnableIOCapture();
  270.  
  271.         fi.Success();
  272.         
  273.     } else {
  274.                 
  275.         delete this;
  276.         fi.ReSignal();
  277.             
  278.     }
  279.  
  280.     return;
  281. }
  282.  
  283.  
  284.  
  285. //------------------------------------------------------------------------------------
  286. void    TCTBChannel::Waitfor( short time)
  287. {
  288.     long t=0;
  289.     long timeout;
  290.     
  291.     timeout = TickCount()+time;
  292.     while (TickCount()<timeout) ++t;
  293.     
  294. }
  295.  
  296.  
  297.  
  298. //---------------------------------------------------------------
  299. void TCTBChannel::InitializeCTB()
  300. {
  301.     CMErr theCMErr = InitCM();
  302.     ASSERTNOERR(theCMErr);
  303.  
  304.     if( theCMErr != 0 )
  305.         FailOSErr(errUnableToInitCTB);
  306.         
  307.     
  308.     CTBUErr     theCTBErr = InitCTBUtilities();
  309.     ASSERTNOERR(theCTBErr);
  310.     if( theCTBErr != 0 )
  311.         FailOSErr(errUnableToInitCTB);
  312.  
  313. }
  314.  
  315.  
  316.  
  317. //--------------------------------------------------------------------------------------
  318. OSErr TCTBChannel::Connect(Ptr configString)
  319. {
  320.     ASSERT(configString);
  321.     ASSERT( fCommState != sConnected);
  322.     ASSERT( fCommState != sConnecting );
  323.         
  324.                         
  325.     FailInfo    fi;
  326.     Try(fi) {
  327.  
  328.         fCTBIdleThread->StartThread();
  329.  
  330.         short    setConfigErr = CMSetConfig(fConnH, configString);
  331.         ASSERT(setConfigErr==0);
  332.         if(setConfigErr)
  333.             FailOSErr(errCommConfigParamMissingOrCorrupt);
  334.  
  335.  
  336.         Boolean    hConnValid = CMValidate(fConnH);        // gratuitous 
  337.         ASSERTNOERR(hConnValid);
  338.  
  339.  
  340.         FailOSErr( this->Open() );
  341.  
  342.  
  343.         fConnEnvironRec.version = curConnEnvRecVers;
  344.         CMErr cmErr = CMGetConnEnvirons(fConnH, &fConnEnvironRec);
  345.         ASSERTNOERR(cmErr);
  346.         FailOSErr(cmErr);
  347.  
  348.  
  349.         this->NetworkLogin();
  350.  
  351.         fCommState = sConnected;
  352.  
  353.  
  354.         fi.Success();
  355.  
  356.  
  357.     } else {
  358.     
  359.         if( ::IsCTBError(fi.error) )
  360.             fi.error = errCantOpenCTBConnection;        // what will be reported to the user.
  361.  
  362.  
  363.         this->Close();
  364.         fCTBIdleThread->StopThread();
  365.  
  366.         fCommState = sDisconnected;
  367.  
  368.     }        
  369.  
  370.  
  371.     return fi.error;
  372.  
  373.  
  374. }
  375.  
  376.  
  377. //---------------------------------------------------------------
  378. void TCTBChannel::NetworkLogin( )
  379. {
  380.     
  381.             
  382. }
  383.  
  384.  
  385.  
  386. //--------------------------------------------------------------------------------------
  387. void TCTBChannel::Disconnect()
  388. {
  389.     while( this->IsIOPending() )
  390.         gCurrentThread->Yield();
  391.     
  392.  
  393.     if( this->IsOpen() ) {
  394.         this->KillAllIO();
  395.         this->Close();
  396.     }
  397.     
  398.     fCTBIdleThread->StopThread();
  399.     
  400. }
  401.  
  402.  
  403. //---------------------------------------------------------------------------
  404. Boolean    TCTBChannel::IsIOPending()
  405. {
  406.     CMStatFlags cmStatus = this->GetCMStatus();
  407.  
  408.         
  409.     CMStatFlags pendingFlags =    cmStatusOpening + cmStatusClosing + 
  410.                                 cmStatusDRPend + cmStatusDWPend    +
  411.                                 cmStatusCRPend + cmStatusCWPend    + 
  412.                                 cmStatusARPend + cmStatusAWPend    +
  413.                                 cmStatusBreakPend + cmStatusListenPend;
  414.  
  415.  
  416.         //    Careful here of the small window of execution where the wakeup thread has been started
  417.         //    but has not yet started the threadtoWake, ie. it remains Stopped until IO completion
  418.         //    routine is called.
  419.         
  420.  
  421.     return ((cmStatus & pendingFlags) != 0) || fWakeupThread->Busy();
  422.  
  423.  
  424. }
  425.  
  426.  
  427. //---------------------------------------------------------------------------
  428. Boolean    TCTBChannel::IsOpen()
  429. {
  430.     CMStatFlags cmStatus = this->GetCMStatus();
  431.     return (cmStatus & cmStatusOpen) != 0;
  432. }
  433.  
  434.  
  435. //---------------------------------------------------------------------------
  436. Boolean    TCTBChannel::IsOpenPending()
  437. {
  438.  
  439.     CMStatFlags cmStatus = this->GetCMStatus();
  440.  
  441.         //     Should we be checking all of these?
  442.         
  443.     return (cmStatus & cmStatusOpening) != 0 || fWakeupThread->Busy();
  444. }
  445.  
  446. //---------------------------------------------------------------------------
  447. Boolean    TCTBChannel::IsReadPending()
  448. {
  449.     CMStatFlags cmStatus = this->GetCMStatus();
  450.         
  451.     return (cmStatus & cmStatusDRPend) != 0 || fWakeupThread->Busy();
  452. }
  453.  
  454.  
  455. //---------------------------------------------------------------------------
  456. Boolean    TCTBChannel::IsWritePending()
  457. {
  458.     CMStatFlags cmStatus = this->GetCMStatus();
  459.         
  460.     return (cmStatus & cmStatusDWPend) != 0 || fWakeupThread->Busy();
  461. }
  462.  
  463.  
  464. //---------------------------------------------------------------------------
  465. long TCTBChannel::DataAvail()
  466. {
  467.     long                datacount = 0;
  468.     CMStatFlags            stat;
  469.     CMBufferSizes        counts;
  470.     
  471.     
  472.     CMErr cmErr = CMStatus(fConnH, counts, &stat);
  473.     ASSERTNOERR(cmErr);
  474.     
  475.     if( cmErr == 0 )        
  476.         datacount = counts[cmDataIn];
  477.         
  478.     return datacount;
  479. }
  480.  
  481.  
  482.  
  483. //---------------------------------------------------------------------------
  484. CMStatFlags        TCTBChannel::GetCMStatus()
  485. {
  486.  
  487.     CMStatFlags        statusFlags = 0;
  488.     CMBufferSizes        counts;
  489.     CMErr    cmErr = CMStatus(fConnH, counts, &statusFlags);
  490.     ASSERTNOERR(cmErr);
  491.  
  492.  
  493.     return statusFlags;
  494. }
  495.  
  496.  
  497. //---------------------------------------------------------------------------------
  498. CMErr TCTBChannel::KillAllIO()
  499. {
  500.     short    allIO = cmDataIn+cmDataOut+cmCntlIn+cmCntlOut+cmAttnIn+cmAttnOut;
  501.     
  502.     CMErr cmErr = CMIOKill(fConnH,allIO);
  503.     ASSERTNOERR(cmErr);
  504.     
  505.     return cmErr;
  506.     
  507. }
  508.  
  509.  
  510. //---------------------------------------------------------------------------------
  511. CMErr TCTBChannel::Abort()
  512. {
  513.     
  514.     CMErr cmErr = CMAbort(fConnH);
  515.     ASSERTNOERR(cmErr);
  516.     
  517.     return cmErr;
  518.     
  519. }
  520.  
  521. //--------------------------------------------------------------------------------------
  522. void     TCTBChannel::FlushRead()
  523. {
  524.     ASSERT(!this->IsReadPending());
  525.     
  526.     CMErr cmErr =CMIOKill(fConnH, cmDataIn);
  527.     
  528.     ASSERTNOERR(cmErr);
  529.  
  530. }
  531.  
  532.  
  533. //--------------------------------------------------------------------------------------
  534. void     TCTBChannel::FlushWrite()
  535. {
  536.     ASSERT(!this->IsWritePending());
  537.     
  538.     CMErr cmErr =CMIOKill(fConnH, cmDataOut);
  539.     ASSERTNOERR(cmErr);
  540.     
  541. }
  542.  
  543.  
  544.  
  545. //--------------------------------------------------------------------------
  546. CMErr TCTBChannel::Open()
  547. {
  548.     CMErr cmErr = 0;
  549.     
  550.     if( fOpenASync ) {
  551.     
  552.         fWakeupThread->SetThreadToWake(gCurrentThread);
  553.         ASSERT( fWakeupThread->GetThreadState() == kStoppedThreadState );
  554.         
  555.         CMOpen(fConnH, kDoAsync, &__CTBCompletorProc, this->OpenTimeout());
  556.         
  557.         gCurrentThread->StopForIO();
  558.         
  559.         fWakeupThread->SetThreadToWake(0);
  560.     
  561.         cmErr = (short)(*fConnH)->userData;
  562.         
  563.                 
  564.     } else {
  565.     
  566.         cmErr = CMOpen(fConnH, kDoSync, 0, this->OpenTimeout());
  567.             
  568.     }
  569.     
  570.     
  571.     ASSERTNOERR(cmErr);
  572.     
  573.     return cmErr;
  574.     
  575.         
  576. }
  577.  
  578.  
  579.  
  580. #pragma segment CTBChannel
  581. //--------------------------------------------------------------------------
  582. OSErr TCTBChannel::Close()
  583. {
  584.     CMErr cmErr = 0;
  585.     
  586.     if( fOpenASync ) {
  587.  
  588.  
  589.         fWakeupThread->SetThreadToWake(gCurrentThread);
  590.         ASSERT( fWakeupThread->GetThreadState() == kStoppedThreadState );
  591.         
  592.         CMClose( fConnH, kDoAsync, &__CTBCompletorProc, this->CloseTimeout(), kDontWaitForPending);
  593.         
  594.         gCurrentThread->StopForIO();
  595.         fWakeupThread->SetThreadToWake(0);
  596.         
  597.         cmErr = (short)(*fConnH)->userData;
  598.  
  599.     } else {
  600.     
  601.         cmErr = CMClose( fConnH, kDoAsync, 0, this->CloseTimeout(), kDontWaitForPending);
  602.         
  603.     }
  604.  
  605.     ASSERTNOERR(cmErr);
  606.         
  607.     return cmErr;
  608.     
  609. }
  610.  
  611.  
  612. //-------------------------------------------------------------------------------
  613. CMErr TCTBChannel::Read( char *theBuffer, long bytesToRead, long timeOut)
  614. {
  615.     CMErr cmErr = 0;
  616.     
  617.     if( fReadASync ) {
  618.  
  619.         fWakeupThread->SetThreadToWake(gCurrentThread);
  620.         ASSERT( fWakeupThread->GetThreadState() == kStoppedThreadState );
  621.         
  622.         CMRead(fConnH, theBuffer, &bytesToRead, cmData, kDoAsync, &__CTBCompletorProc, timeOut, &fConnEnvironRec.flags);
  623.         
  624.         gCurrentThread->StopForIO();
  625.         fWakeupThread->SetThreadToWake(0);
  626.         
  627.         cmErr = (short)(*fConnH)->userData;
  628.  
  629.     
  630.     } else {
  631.     
  632.         cmErr = CMRead(fConnH, theBuffer, &bytesToRead, cmData, kDoSync, 0, timeOut, &fConnEnvironRec.flags);
  633.         
  634.     }
  635.  
  636.  
  637.     ASSERTNOERR(cmErr);
  638.     
  639.     if( cmErr == 0 && gEnableIOTrace )
  640.         gReadCaptureFile.Write(theBuffer,bytesToRead);        // ignore errors
  641.         
  642.     
  643.     return cmErr;
  644.     
  645. }
  646.  
  647.  
  648. //-------------------------------------------------------------------------------
  649. CMErr TCTBChannel::Write( char *theBuffer, long bytesToWrite, long timeOut)
  650. {
  651.     CMErr cmErr = 0;
  652.     
  653.     if( fWriteASync ) {
  654.     
  655.         fWakeupThread->SetThreadToWake(gCurrentThread);
  656.         ASSERT( fWakeupThread->GetThreadState() == kStoppedThreadState );
  657.     
  658.         CMWrite(fConnH, theBuffer, &bytesToWrite, cmData, kDoAsync, &__CTBCompletorProc,timeOut, fConnEnvironRec.flags);
  659.     
  660.         gCurrentThread->StopForIO();
  661.         fWakeupThread->SetThreadToWake(0);
  662.         
  663.         cmErr = (short)(*fConnH)->userData;
  664.  
  665.     } else {
  666.     
  667.         cmErr = CMWrite(fConnH, theBuffer, &bytesToWrite, cmData, kDoSync, 0 ,timeOut, fConnEnvironRec.flags);
  668.     }
  669.  
  670.  
  671.     ASSERTNOERR(cmErr);
  672.     
  673.     
  674.     if( cmErr == 0 && gEnableIOTrace )
  675.         gWriteCaptureFile.Write(theBuffer,bytesToWrite);        // ignore errors
  676.         
  677.  
  678.  
  679.     return cmErr;
  680.  
  681. }
  682.  
  683.  
  684.  
  685.  
  686.  
  687. //-------------------------------------------------------------------------------
  688. void TCTBChannel::WriteBytes( void *theBuffer, long bytesToWrite)
  689. {
  690.     FailOSErr( this->Write((char*)theBuffer,bytesToWrite,this->WriteTimeout()) );
  691. }
  692.  
  693.  
  694.  
  695. //-------------------------------------------------------------------------------
  696. pascal void        TCTBChannel::__CTBCompletorProc(ConnHandle  theConnectionHandle)
  697. {
  698.  
  699.     TCTBChannel* thisChannel = (TCTBChannel*) (*theConnectionHandle)->refCon;    
  700.     long a5 = thisChannel->fWakeupThread->GetThreadA5();
  701.     long curA5 = ::SetA5(a5);
  702.  
  703.         
  704.     (*theConnectionHandle)->userData = (*theConnectionHandle)->errCode;
  705.          
  706.     thisChannel->fWakeupThread->StartThreadFromCompletionRoutine();
  707.  
  708.         
  709.     ::SetA5(curA5);
  710.  
  711.         
  712. }
  713.  
  714.  
  715.  
  716. //---------------------------------------------------------------------------------
  717. void TCTBChannel::IdleChannel()
  718. {
  719.     CMStatFlags flags = this->GetCMStatus();
  720.     
  721.     if( flags != 0 )
  722.         CMIdle(fConnH);
  723.  
  724.  
  725. }
  726.  
  727.  
  728. //---------------------------------------------------------------------------------
  729. char TCTBChannel::ReadByte()
  730. {    
  731.     char c;
  732.     FailOSErr( this->Read(&c ,1,this->ReadTimeout() ) );
  733.     return c;
  734. }
  735.  
  736.  
  737. //---------------------------------------------------------------------------------
  738. void TCTBChannel::ReadBytes(char *theBuffer, long bytesToRead )
  739. { 
  740.     FailOSErr( this->Read(theBuffer,bytesToRead,this->ReadTimeout() ) ); 
  741. }
  742.  
  743.  
  744. //-------------------------------------------------------------------------------
  745. char TCTBChannel::WaitFor(char waitFor)
  746. {
  747.  
  748.     char c;
  749.     do {
  750.     
  751.         c =  this->ReadByte();
  752.         ASSERTPRINT( c== waitFor,("CTB waiting for %0X, recieived = %0x\n",waitFor,c) );
  753.         
  754.     } while( c != waitFor );
  755.     
  756.     return c;
  757.     
  758. }
  759.  
  760.  
  761.  
  762. //-------------------------------------------------------------------------------
  763. char TCTBChannel::WaitForOneOf(char *searchString)
  764. {
  765.  
  766.     char c = 0;
  767.     do {
  768.         c = this->ReadByte();
  769.     } while( !strchr(searchString, c) );
  770.  
  771.  
  772.     return c;
  773.  
  774. }
  775.  
  776.  
  777. //------------------------------------------------------------------------------
  778. void    TCTBChannel::WaitForString(char* searchString)
  779. {
  780.  
  781.     char c = 0;
  782.     long matchIndex = 0;    
  783.     
  784.     long searchStringLen = strlen(searchString);
  785.     
  786.     while( matchIndex < searchStringLen ) {
  787.  
  788.         c = this->ReadByte();
  789.  
  790.         if (  c == searchString[matchIndex] )
  791.             matchIndex++;
  792.         else if ( c == searchString[0] )            // does it match from the beginning?
  793.             matchIndex = 1;
  794.         else
  795.             matchIndex = 0;
  796.  
  797.  
  798.     }
  799.     
  800.     
  801.     return;
  802. }
  803.  
  804.  
  805.  
  806. //------------------------------------------------------------------------------
  807. void    TCTBChannel::SendString(char*    sendString)
  808. {
  809.     unsigned long    sendLength = strlen(sendString);
  810.     
  811.     FailOSErr( this->Write( sendString, sendLength, this->WriteTimeout()) );
  812.  
  813. }
  814.  
  815.  
  816.  
  817.  
  818. //-------------------------------------------------------------------------------------
  819. void TCTBChannel::SetCTBParametersFromResource(short resID)
  820. {
  821.  
  822.     CommParameterResource** commParams = (CommParameterResource**)::Get1Resource('ctbp',resID);
  823.     FailNILResource((Handle)commParams);
  824.  
  825.  
  826.     fReadTimeout = (*commParams)->readTimeout == -1 ? -1 : (*commParams)->readTimeout*60;
  827.     fWriteTimeout = (*commParams)->writeTimeout == -1 ? -1 : (*commParams)->writeTimeout*60;
  828.     fOpenTimeout = (*commParams)->openTimeout == -1 ? -1 : (*commParams)->openTimeout*60;
  829.     fCloseTimeout = (*commParams)->closeTimeout == -1 ? -1 : (*commParams)->closeTimeout*60;
  830.  
  831.     fOpenASync  = ((*commParams)->flags & kOpenASync) != 0;
  832.     fCloseASync = ((*commParams)->flags & kCloseASync) != 0;
  833.     fReadASync  = ((*commParams)->flags & kReadASync) != 0;
  834.     fWriteASync = ((*commParams)->flags & kWriteASync) != 0;
  835.  
  836.  
  837.     fConfigBufSize = (*commParams)->configStrBufSize;
  838.     
  839.  
  840.     fBaudRate = (*commParams)->minimumBaudRate;
  841.     
  842.     ReleaseResource((Handle)commParams);
  843.     
  844. }
  845.  
  846.  
  847.  
  848. //---------------------------------
  849. //    T M o d e m C h a n n e l
  850. //---------------------------------
  851.  
  852.  
  853. //----------------------------------------------------------
  854. TModemChannel::TModemChannel()
  855. {
  856.     fAccessNetwork = SPRINTNET;
  857.     
  858.     fNoCarrierDetectRefNum = 0;
  859.     fNoCarrierDetected = false;
  860.  
  861.  
  862. }
  863.  
  864. //----------------------------------------------------------
  865. void TModemChannel::IModemChannel(StringPtr toolName, TExternalSlot* exSlot)
  866. {
  867.  
  868.     this->ICTBChannel(kModemToolParams,toolName, exSlot);
  869.  
  870.  
  871.         //    NO CARRIER Filter
  872.     Str255    noCarrierStr;
  873.     GetIndString(noCarrierStr, kCTBStreamSearchStrings, kNoCarrierStr);
  874.     FailResError();
  875.     fNoCarrierDetectRefNum = CMAddSearch(fConnH,noCarrierStr,0,NoCarrierDetectProc);
  876.  
  877.  
  878. }
  879.  
  880.  
  881.  
  882. //----------------------------------------------------------
  883. void TModemChannel::MakeConnection()
  884. {
  885.     Ptr    configStr =    0;
  886.     
  887.     FailInfo fi;
  888.     Try(fi) {
  889.  
  890.  
  891.         long    buffSize = fConfigBufSize;
  892.         configStr = NewPtr( buffSize );
  893.         FailMemError();
  894.         VOLATILE(configStr);
  895.         
  896.         
  897.             //    Read the attribute that holds the config string.
  898.         Handle rsrc =    ::Get1Resource('rstr',kCTBConfigStrAttrTypeResID);
  899.         FailNILResource(rsrc);
  900.         CAttributeType configStrAttrType( (RStringHandle)rsrc);
  901.  
  902.  
  903.         OSErr osErr = fExternalSlot->ReadSlotAttribute(configStrAttrType,configStr ,buffSize);
  904.         FailOSErr(osErr);
  905.  
  906.  
  907.         FailOSErr (this->Connect(configStr) );
  908.     
  909.         if(configStr != 0 )
  910.             DisposePtr(configStr);
  911.         
  912.         fi.Success();
  913.         
  914.     } else {
  915.     
  916.         if(configStr != 0 )
  917.             DisposePtr(configStr);
  918.         
  919.         fi.ReSignal();
  920.         
  921.     }
  922.  
  923.  
  924. }
  925.  
  926. //------------------------------------------------------------------------------
  927. void TModemChannel::NetworkLogin( )
  928. {
  929.     switch(fAccessNetwork) {
  930.     
  931.     case SPRINTNET:
  932.         this->SprintNetLogin();
  933.     break;
  934.     
  935.     default:
  936.         // if no network, we assume we are connecting direectly to an eWorld modem, no nmetwork login necessary
  937.     break;
  938.         
  939.     };
  940.  
  941.     this->WaitForString("CONNECT");
  942.     
  943.     
  944. }
  945.  
  946.  
  947.  
  948. //-------------------------------------------------------------------------------
  949. pascal void    TModemChannel::NoCarrierDetectProc(ConnHandle  hConn,Ptr /*matchPtr*/, long /*refNum */)
  950. {
  951.  
  952.     TModemChannel* thisChannel = (TModemChannel*) (*hConn)->refCon;    
  953.     thisChannel->fNoCarrierDetected = true;
  954.     
  955. }
  956.  
  957.  
  958. //------------------------------------------------------------------------------
  959. void TModemChannel::SprintNetLogin ()
  960. {
  961.   
  962.     this->Waitfor(300);   // ••Hack•• Cant explain why this is necessary but without it we do not connect, JB
  963.    
  964.     if (this->fBaudRate <= 2400)
  965.         this->SendString("\x0D\x44\x0D");
  966.     else 
  967.         this->SendString("@D\x0D");
  968.  
  969.  
  970.     char c = this->WaitForOneOf("?=@");
  971.     switch ( c ) {
  972.    
  973.     case  '@':           //     we're at Sprintnet's command prompt
  974.         break;
  975.             
  976.     case  '=':           //    support update_800 connections
  977.       
  978.         this->SendString("D1\x0D");
  979.         
  980.         c = this->WaitForOneOf( "?=@");
  981.         switch ( c ) {
  982.         
  983.         case  '@':
  984.                  break;
  985.                  
  986.          case  '=':
  987.             this->SendString("703,555\x0D");
  988.             this->WaitForOneOf("@");
  989.             break;
  990.             
  991.         case '?':
  992.             ASSERTPRINT(false,("Gotta ? in TModemChannel::SprintnetLogin ") );
  993.             FailOSErr(errCantOpenCTBConnection);
  994.             break;
  995.         
  996.         default:    // should NEVER happen
  997.             ASSERTPRINT(false,("Gotta unexpected char in TModemChannel::SprintnetLogin "));
  998.             FailOSErr(errCantOpenCTBConnection);
  999.             break;
  1000.         };
  1001.         
  1002.         break;
  1003.         
  1004.     case '?':
  1005.         ASSERTPRINT(false,("Gotta ? in TModemChannel::SprintnetLogin "));
  1006.         FailOSErr(errCantOpenCTBConnection);
  1007.         break;
  1008.         
  1009.     default:        // should NEVER happen
  1010.         ASSERTPRINT(false,("Gotta ? in TModemChannel::SprintnetLogin "));
  1011.         break;
  1012.         
  1013.     }
  1014.  
  1015.  
  1016.    // if we get here, we're at Sprint's command prompt... send our connection address */
  1017.    this->FlushRead();
  1018.    
  1019.    Handle rsrc = ::Get1Resource('cstr',kSprintConnectAddrResID);
  1020.    FailNILResource(rsrc);
  1021.    char    addrBuf[256];
  1022.    BlockMove((Ptr)*rsrc,(Ptr)addrBuf,strlen((char const *)*rsrc)+1);
  1023.    
  1024.     this->SendString(addrBuf);
  1025.     fCommState = sConnecting;
  1026.  
  1027.  
  1028.  
  1029.    return;
  1030. }
  1031.  
  1032.  
  1033.  
  1034. //---------------------------------
  1035. //    T X 2 5 C h a n n e l
  1036. //---------------------------------
  1037.  
  1038.  
  1039.  
  1040. //----------------------------------------------------------
  1041. TX25Channel::TX25Channel()
  1042. {
  1043. }
  1044.  
  1045.  
  1046. //----------------------------------------------------------
  1047. void TX25Channel::IX25Channel(StringPtr toolName, TExternalSlot* exSlot)
  1048. {
  1049.     this->ICTBChannel(kX25ToolParams,toolName, exSlot);
  1050.  
  1051. }
  1052.  
  1053. //----------------------------------------------------------
  1054. void TX25Channel::NetworkLogin( )
  1055. {
  1056.  
  1057.     fCommState = sConnecting;
  1058.     char charFound = this->WaitForOneOf("\x11");        
  1059.  
  1060. }
  1061.  
  1062. //----------------------------------------------------------
  1063. void TX25Channel::MakeConnection()
  1064. {
  1065.  
  1066.     //    We try every 'mpad' resource before giving up.  There is a
  1067.     //    'mpad' resource for every MacX25 server we should try.
  1068.     
  1069.     
  1070.     Ptr    configStr = 0;
  1071.  
  1072.     FailInfo    fi;
  1073.     Try(fi) {
  1074.     
  1075.         long    buffSize = fConfigBufSize;
  1076.         configStr = NewPtr( buffSize );            // Caller is responsible for Disposing.
  1077.         FailMemError();
  1078.         VOLATILE(configStr);
  1079.  
  1080.  
  1081.         OSErr osErr = errCommConfigParamMissingOrCorrupt;        // in case there are NO 'mpad' resources
  1082.         CResourceIterator iter('mpad');
  1083.         for( Handle rsrc = iter.FirstResource(); iter.More(); rsrc = iter.NextResource() ) {
  1084.         
  1085.             strcpy((char*)configStr,(char*)*rsrc);
  1086.             osErr = this->Connect(configStr);
  1087.             if( osErr == 0 )
  1088.                 break;
  1089.                 
  1090.             //    else try the next server...
  1091.             extern Boolean gAssertsEnabled;
  1092.             if( gAssertsEnabled ) {
  1093.                 Str255    rsrcName;
  1094.                 rsrcName[0] = 0;
  1095.                 short resID;
  1096.                 ResType resType;
  1097.                 GetResInfo(rsrc,&resID,&resType,rsrcName);
  1098.                 ASSERTPRINT(false,("MacX25Server %P not available.\n",rsrcName) );
  1099.             }
  1100.             
  1101.         
  1102.         }
  1103.         
  1104.         FailOSErr(osErr);
  1105.  
  1106.  
  1107.  
  1108.         if(configStr != 0 )
  1109.             DisposePtr(configStr);
  1110.  
  1111.         
  1112.         fi.Success();
  1113.         
  1114.         
  1115.     } else {
  1116.     
  1117.         if(configStr != 0 )
  1118.             DisposePtr(configStr);
  1119.  
  1120.  
  1121.         fi.ReSignal();
  1122.         
  1123.     }
  1124.     
  1125.     
  1126. }
  1127.  
  1128.  
  1129.  
  1130. //-------------------------------------
  1131. //     T C T B I d l e T h r e a d
  1132. //--------------------------------------
  1133.  
  1134.  
  1135. //-------------------------------------------------------------------------------
  1136. TCTBIdleThread::TCTBIdleThread()
  1137. {
  1138.  
  1139.     fCTBChannel = 0;
  1140. }
  1141.  
  1142.  
  1143. //-------------------------------------------------------------------------------
  1144. void TCTBIdleThread::ICTBIdleThread(TCTBChannel* ctbChannel)
  1145. {
  1146.     this->ICooperativeThread('cidl',kCTBIdleThreadStackSize,kNewSuspend);        // start in ::Connect
  1147.     fCTBChannel = ctbChannel;
  1148. }
  1149.  
  1150. //-------------------------------------------------------------------------------
  1151. void* TCTBIdleThread::ThreadMain()
  1152. {
  1153.  
  1154.     while( true ) {
  1155.         
  1156.         FailInfo fi;
  1157.         Try(fi) {
  1158.             fCTBChannel->IdleChannel();
  1159.             this->Yield();    
  1160.             fi.Success();
  1161.         }
  1162.         
  1163.     }
  1164.     
  1165.     return this;        
  1166. }
  1167.  
  1168.